#-*- coding=utf-8 -*-
import pandas as pd
import os,random,subprocess,time,sys
from datetime import date
import pandas as pd
import logging,codecs
import datetime
import pyautogui
import psutil
from PIL import Image
import pyscreeze,cv2



def ReadFile(filePath):
    with codecs.open(filePath, "r") as f:
        return f.read()
def WriteFile(filePath, u, encoding="utf-8"):
    # with codecs.open(filePath,"w",encoding) as f:
    with codecs.open(filePath, "wb") as f:
        f.write(u.encode(encoding, errors="ignore"))
def CSV_2_UTF8(src, dst):
    content = ReadFile(src)
    WriteFile(dst, content, encoding="utf-8")

def  每手取整(代码,数量,仓位):
    if 代码[0:2]!="68":
        取整数量=round(数量*仓位,-2)
    elif 代码[0:2]=="68":
        取整数量=round(数量*仓位,0)   
    return 取整数量

#获取本地路径下的基础数据
def joinPath(fileName):
    filePath=os.path.join(sys.path[0],fileName)
    return filePath

#  指定目录下,将数据带时间后缀保存为csv格式
def saveCsvByTime(fileNanme,saveData,TimeFlag):
    # OQPath:导出目录,fileNanme：文件名前缀,saveData：保存的数据
    now = datetime.datetime.now()
    if TimeFlag==True:
        filename = f"{fileNanme}_{now.strftime('%Y-%m-%d_%H-%M-%S')}.csv"
    else:
        filename = f"{fileNanme}.csv"
    full_path = joinPath(filename)
    saveData.to_csv(full_path,index=False)
 
 #  保存日志到指定目录下   
def logfun(isfile):
    logger = logging.getLogger()
    # 输出到console
    # logger.setLevel(level=logging.DEBUG)
    logger.setLevel(level=logging.INFO) # 某些python库文件中有一些DEBUG级的输出信息，如果这里设置为DEBUG，会导致console和log文件中写入海量信息
    # console_formatter = colorlog.ColoredFormatter(
    #     # fmt='%(log_color)s[%(asctime)s.%(msecs)03d] %(filename)s -> %(funcName)s line:%(lineno)d [%(levelname)s] : %(message)s',
    #     fmt=' %(levelname)s: %(message)s'
    #     # datefmt='%Y-%m-%d  %H:%M:%S'
    # )
    console = logging.StreamHandler()  # 输出到console的handler
    console.setLevel(logging.INFO)
    # console.setFormatter(console_formatter)
    logger.addHandler(console)
    # 输出到文件
    if isfile:
        # 设置文件名
        now = datetime.datetime.now()
        filename = f"log_{now.strftime('%Y-%m-%d_%H-%M-%S')}.txt"
        log_path=os.path.join(os.getcwd(),'log')
        if not os.path.exists(log_path):
            os.mkdir(log_path)
        logfile = log_path + '/'+filename
        # 设置文件日志格式
        filer = logging.FileHandler(logfile,mode='w') # 输出到log文件的handler
        # filer.setLevel(level=logging.DEBUG)
        file_formatter = logging.Formatter(
            fmt='%(asctime)s - %(levelname)s: %(message)s'
        )
        # formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s")
        filer.setFormatter(file_formatter)
        logger.addHandler(filer)
    return logger

# 开启保存日志 
log=logfun(isfile=True)

#根据OQ导出的数据：融券标的、融资融券合约、持仓数据，生成自动化执行清单,资金账号按&连接
def 生成执行表单(资金账号列表,账号类型列表,自动导出目录):
    # 登录成功后,从自动导出获取交易数据列表并转化成可执行清单列表
    执行轮次=5
    资金账号列表=资金账号列表.split("&")
    账号类型列表=账号类型列表.split("&")
    CSV_2_UTF8(os.path.join(自动导出目录,"positioninfo_"+date.today().strftime("%Y%m%d")+".csv"), os.path.join(自动导出目录,"positioninfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    CSV_2_UTF8(os.path.join(自动导出目录,"enslo_"+date.today().strftime("%Y%m%d")+".csv"), os.path.join(自动导出目录,"enslo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    CSV_2_UTF8(os.path.join(自动导出目录,"compactinfo_"+date.today().strftime("%Y%m%d")+".csv"), os.path.join(自动导出目录,"compactinfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    持仓列表=pd.read_csv(os.path.join(自动导出目录,"positioninfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    持仓列表.drop(持仓列表.tail(1).index,inplace=True)  #删除最后一行换行
    持仓列表["账号"]=持仓列表["账号"].astype('int64').astype('str')
    融券标的=pd.read_csv(os.path.join(自动导出目录,"enslo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    融券标的.drop(融券标的.tail(1).index,inplace=True)
    融券标的["账号"]=融券标的["账号"].astype('int64').astype('str')
    融资融券合约=pd.read_csv(os.path.join(自动导出目录,"compactinfo_"+date.today().strftime("%Y%m%d")+"_utf.csv"))
    融资融券合约.drop(融资融券合约.tail(1).index,inplace=True)
    融资融券合约["账号"]=融资融券合约["账号"].astype('int64').astype('str')
    执行清单=pd.DataFrame(columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用'])
    i=0
    for 资金账号 in 资金账号列表:
        i=i+1
        if 资金账号[0:4]!="8888":
            #为股票账户,生成买入、卖出组合,只输出可用数量前10的
            资金账号持仓信息=持仓列表[持仓列表["账号"]==资金账号].sort_values(by="可用数量",ascending=False, inplace=False).head(10)
            for 证券代码 in 资金账号持仓信息["securityID"]:
                最大可执行总量=资金账号持仓信息[资金账号持仓信息["securityID"]==证券代码]["可用数量"].iloc[0]
                单轮委托量=每手取整(证券代码,最大可执行总量/执行轮次,0.33)
                持仓数量=资金账号持仓信息[资金账号持仓信息["securityID"]==证券代码]["当前数量"].iloc[0]
                普通卖出可用数=最大可执行总量
                卖券还款可用数=0
                未还融资数量=0
                未还融券数量=0
                融券可用头寸=0
                执行指令=["手工T0",资金账号,账号类型列表[i-1],证券代码,"买入","卖出",单轮委托量, '5', 持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                执行列表=pd.DataFrame([执行指令])
                执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']

                执行清单=pd.concat([执行清单,执行列表])
                # print(执行清单)
                执行指令=["传统模式",资金账号,账号类型列表[i-1],证券代码,"买入","卖出",单轮委托量, '5', 持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                执行列表=pd.DataFrame([执行指令])
                执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                执行清单=pd.concat([执行清单,执行列表])
        else :
            资金账号持仓信息=持仓列表[(持仓列表["账号"]==资金账号) & (持仓列表["可用数量"]>0)].sort_values(by="可用数量",ascending=False, inplace=False)

            if 账号类型列表[i-1]=="极速两融":
                可融券标的列表=融券标的[(融券标的["账号"]==资金账号) & (融券标的["专项可融头寸"]>0)].sort_values(by="专项可融头寸",ascending=False, inplace=False)
            elif 账号类型列表[i-1]=="普通两融":
                可融券标的列表=融券标的[(融券标的["账号"]==资金账号) & (融券标的["普通可融头寸"]>0)].sort_values(by="普通可融头寸",ascending=False, inplace=False)
            未还融券负债=融资融券合约[(融资融券合约["账号"]==资金账号) &  (融资融券合约["合约类型"]=="1") & (融资融券合约["未还合约数量"]>0)].sort_values(by="未还合约数量",ascending=False, inplace=False)
            未还融资负债=融资融券合约[(融资融券合约["账号"]==资金账号 )  & (融资融券合约["合约类型"]=="0") & (融资融券合约["未还合约数量"]>0)].sort_values(by="未还合约数量",ascending=False, inplace=False)
            #满足可用>0的代码交集(有融券头寸和持仓)
            有头寸可还券标的=list(set(可融券标的列表["securityID"].tolist())&set(资金账号持仓信息["securityID"].tolist()))
            print(f"有头寸可还的融券标的：{len(有头寸可还券标的)}")
            #为信用账户,生成融券卖出、现券还券组合,只输出前10的
            买卖组合=["融券卖出现券还券","融券卖出买券还券","普通卖出融资买入","普通卖出普通买入","卖券还款融资买入","卖券还款普通买入"]
            for 证券代码 in 有头寸可还券标的:
                未还融资数量=未还融资负债[(未还融资负债["账号"]==资金账号) & (未还融资负债["securityID"]==证券代码)]["未还合约数量"].sum()
                未还融券数量=未还融券负债[(未还融券负债["账号"]==资金账号) & (未还融券负债["securityID"]==证券代码)]["未还合约数量"].sum()
                持仓数量=资金账号持仓信息[资金账号持仓信息["securityID"]==证券代码]["当前数量"].iloc[0]
                卖券还款可用数=未还融资数量
                普通卖出可用数=资金账号持仓信息[资金账号持仓信息["securityID"]==证券代码]["可用数量"].iloc[0]-卖券还款可用数
                if 账号类型列表[i-1]=="极速两融":
                    融券可用头寸=融券标的[(融券标的["账号"]==资金账号) & (融券标的["securityID"]==证券代码)]["专项可融头寸"].iloc[0]
                elif 账号类型列表[i-1]=="普通两融":
                    融券可用头寸=融券标的[(融券标的["账号"]==资金账号) & (融券标的["securityID"]==证券代码)]["普通可融头寸"].iloc[0]
                for 组合 in 买卖组合:
                    if 组合=="融券卖出现券还券":
                        最大可执行总量=min(未还融券数量,持仓数量,融券可用头寸)
                        单轮委托量=每手取整(证券代码,最大可执行总量/执行轮次,0.33)
                        执行指令=["手工T0",资金账号,账号类型列表[i-1],证券代码,"融券卖出","现券还券",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']

                        执行清单=pd.concat([执行清单,执行列表])
                        执行指令=["传统模式",资金账号,账号类型列表[i-1],证券代码,"融券卖出","现券还券",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])                   
                    
                    elif 组合=="融券卖出买券还券":
                        最大可执行总量=min(未还融券数量,融券可用头寸)

                        单轮委托量=每手取整(证券代码,最大可执行总量/执行轮次,0.33)
                        执行指令=["手工T0",资金账号,账号类型列表[i-1],证券代码,"融券卖出","买券还券",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])
                        执行指令=["传统模式",资金账号,账号类型列表[i-1],证券代码,"融券卖出","买券还券",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])   
                    elif 组合=="普通卖出融资买入":
                        最大可执行总量=普通卖出可用数
                        单轮委托量=每手取整(证券代码,最大可执行总量/执行轮次,0.33)
                        执行指令=["手工T0",资金账号,账号类型列表[i-1],证券代码,"融资买入","普通买入",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])
                        执行指令=["传统模式",资金账号,账号类型列表[i-1],证券代码,"融资买入","普通买入",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])
                    elif 组合=="普通卖出普通买入":
                        最大可执行总量=普通卖出可用数
                        单轮委托量=每手取整(证券代码,最大可执行总量/执行轮次,0.33)
                        执行指令=["手工T0",资金账号,账号类型列表[i-1],证券代码,"普通买入","普通卖出",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])
                        执行指令=["传统模式",资金账号,账号类型列表[i-1],证券代码,"普通买入","普通卖出",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])                      
                    elif 组合=="卖券还款融资买入":
                        最大可执行总量=卖券还款可用数
                        单轮委托量=每手取整(证券代码,最大可执行总量/执行轮次,0.33)
                        执行指令=["手工T0",资金账号,账号类型列表[i-1],证券代码,"融资买入","卖券还款",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])
                        执行指令=["传统模式",资金账号,账号类型列表[i-1],证券代码,"融资买入","卖券还款",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])   
                    elif 组合=="卖券还款普通买入":
                        最大可执行总量=卖券还款可用数
                        单轮委托量=每手取整(证券代码,最大可执行总量/执行轮次,0.33)
                        执行指令=["手工T0",资金账号,账号类型列表[i-1],证券代码,"普通买入","卖券还款",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表])
                        执行指令=["传统模式",资金账号,账号类型列表[i-1],证券代码,"普通买入","卖券还款",单轮委托量, 执行轮次,  持仓数量,普通卖出可用数, 卖券还款可用数, 未还融资数量, 未还融券数量,融券可用头寸, 最大可执行总量,'Y']
                        执行列表=pd.DataFrame([执行指令])
                        执行列表.columns=['菜单', '账号','账号类型', '证券代码', '开仓方向', '平仓方向', '单轮委托量', '多轮执行次数', '持仓数量','普通卖出可用数', '卖券还款可用数', '未还融资数量', '未还融券数量',  '融券可用头寸','最大可执行总量','启用']
                        执行清单=pd.concat([执行清单,执行列表]) 
    saveCsvByTime("T0执行清单",执行清单,True)
    return 执行清单
    


# T0执行清单=生成执行表单("888821600235","极速两融",r"C:\Users\AXZQ\Desktop\T0")
# # T0执行清单=T0执行清单[T0执行清单["单轮委托量"]>0]
# print(len(T0执行清单))


T0执行清单=pd.read_csv(r"C:\Users\AXZQ\Desktop\T0\T0执行清单_2023-05-23_23-16-09.csv")
T0执行清单=T0执行清单[T0执行清单["启用"]=="Y"]
log.info("加载T0执行清单")




控件等待时间=1


#  图片识别点击控件
def getButton(targetImage):
    # 屏幕缩放系数 mac缩放是2 windows一般是1
    screenScale = 1
    # 事先读取按钮截图
    target = cv2.imread(targetImage, cv2.IMREAD_GRAYSCALE)
    # 先截图
    screenshot = pyscreeze.screenshot('my_screenshot.png')
    # 读取图片 灰色会快
    temp = cv2.imread(r'my_screenshot.png', cv2.IMREAD_GRAYSCALE)
    theight, twidth = target.shape[:2]
    tempheight, tempwidth = temp.shape[:2]
    # 先缩放屏幕截图 INTER_LINEAR INTER_AREA
    scaleTemp = cv2.resize(temp, (int(tempwidth / screenScale), int(tempheight / screenScale)))
    stempheight, stempwidth = scaleTemp.shape[:2]
    # 匹配图片
    res = cv2.matchTemplate(scaleTemp, target, cv2.TM_CCOEFF_NORMED)
    mn_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
    if (max_val >= 0.9):
        # 计算出中心点
        top_left = max_loc
        bottom_right = (top_left[0] + twidth, top_left[1] + theight)
        tagHalfW = int(twidth / 2)
        tagHalfH = int(theight / 2)
        tagCenterX = top_left[0] + tagHalfW
        tagCenterY = top_left[1] + tagHalfH
        # 左键点击屏幕上的这个位置
        pyautogui.click(tagCenterX, tagCenterY, button='left')
    else:
        print("没找到")
        log.info(f"没找到图片{targetImage}")



#   自动点击客户端菜单
def getAutoOutput(orderList,actionList):
    for actionRPA in actionList:

        if actionRPA=='enter':
            pyautogui.press('enter')
            time.sleep(控件等待时间)

        elif actionRPA[0:2]=='移动':
            x,y=pyautogui.position()
            if actionRPA[2:3]=='W':
                pyautogui.moveTo(x-int(actionRPA[3:]),y,duration=0.25)
                pyautogui.click(x-int(actionRPA[3:]),y) 
                time.sleep(控件等待时间)

        elif actionRPA=='证券代码':
            pyautogui.typewrite(orderList[0][0:6])
            time.sleep(控件等待时间) 
        elif actionRPA=='交易方向':
            if orderList[1]=="买入" or orderList[1]=="普通买入":
                pyautogui.hotkey("F4")
                time.sleep(控件等待时间)
            elif orderList[1]=="卖出" or orderList[1]=="普通卖出":
                pyautogui.hotkey("F5")
                time.sleep(控件等待时间)
            elif orderList[1]=="融资买入" :
                pyautogui.hotkey("F6")
                time.sleep(控件等待时间)
            elif orderList[1]=="卖券还款":
                pyautogui.hotkey("F8")
                time.sleep(控件等待时间)
            elif orderList[1]=="融券卖出" :
                pyautogui.hotkey("F7")
                time.sleep(控件等待时间)

        elif actionRPA=='超价':
            if orderList[1]=="买入" or orderList[1]=="普通买入" or orderList[1]=="融资买入" or orderList[1]=="买券还券"  :
                pyautogui.press("up")
                time.sleep(控件等待时间)
            elif orderList[1]=="卖出" or orderList[1]=="普通卖出" or orderList[1]=="卖券还款" or orderList[1]=="买券还券"  :
                pyautogui.press("down")
                time.sleep(控件等待时间)
            elif orderList[1]=="融券卖出" :
                time.sleep(控件等待时间)

        elif actionRPA[0:3]=='tab':
            for i in range(int(actionRPA[3])):
                pyautogui.press('tab')
            time.sleep(控件等待时间)


        elif actionRPA=='委托数量':
            pyautogui.typewrite(str(int(orderList[2])))
            time.sleep(控件等待时间)     
        else:
            imagePath=os.path.join(sys.path[0],actionRPA)
            getButton(imagePath)
            time.sleep(控件等待时间)

time.sleep(10)
T0执行清单["开仓提交时间"]=""
T0执行清单["开仓提交时间-1分钟"]=""
T0执行清单["开仓提交时间+1分钟"]=""
T0执行清单["平仓提交时间"]=""
T0执行清单["平仓提交时间-1分钟"]=""
T0执行清单["平仓提交时间+1分钟"]=""
T0执行清单["开仓委托成功"]=""
T0执行清单["平仓委托成功"]=""
for index, row in T0执行清单.iterrows():
    print(index)
    T0代码=row["证券代码"]
    开仓方向=row["开仓方向"]
    平仓方向=row["平仓方向"]
    T0数量=row["单轮委托量"]
    菜单=row["菜单"]
    orderOpen=[T0代码,开仓方向,T0数量,菜单]
    orderClose=[T0代码,平仓方向,T0数量,菜单]
    if 菜单=="手工T0" and row["平仓方向"] not in ["现券还券","买券还券"] :
        actionList1=["hand-1.png","移动W130","证券代码","交易方向","超价","tab1","委托数量","enter"]
        actionList2=["hand-1.png","移动W130","证券代码","交易方向","超价","tab1","委托数量","enter"]
    elif 菜单=="手工T0" and 平仓方向=="现券还券":
        actionList1=["hand-1.png","移动W130","证券代码","交易方向","超价","tab1","委托数量","enter"]       
        actionList2=["trad-1.png","tab1","证券代码","tab2","委托数量","tab2","enter","tab5","enter","enter","trad-2.png"]  
    elif 菜单=="手工T0" and 平仓方向=="买券还券":
        actionList1=["hand-1.png","移动W130","证券代码","交易方向","超价","tab1","委托数量","enter"]       
        actionList2=["tradBH-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab6","enter","enter","trad-2.png"] 

    elif 菜单=="传统模式" and 开仓方向=="融券卖出" and 平仓方向=="现券还券": 
        actionList1=["tradSR-1.png","tab1","证券代码","tab1","tab1","委托数量","tab2","enter","tab7","enter","enter","trad-2.png"]  
        actionList2=["trad-1.png","tab1","证券代码","tab2","委托数量","tab2","enter","tab5","enter","enter","trad-2.png"]     

    elif  菜单=="传统模式" and 开仓方向=="买入" and 平仓方向=="卖出":
        actionList1=["tradB-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab6","enter","enter","trad-2.png"]
        actionList2=["tradS-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab7","enter","enter","trad-2.png"]  
    elif  菜单=="传统模式" and 开仓方向=="融券卖出" and 平仓方向=="买券还券":
        actionList1=["tradSR-1.png","tab1","证券代码","tab1","tab1","委托数量","tab2","enter","tab7","enter","enter","trad-2.png"]  
        actionList2=["tradBH-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab6","enter","enter","trad-2.png"]      
    elif  菜单=="传统模式" and  开仓方向=="普通买入" and 平仓方向=="普通卖出":
        actionList1=["tradB-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab6","enter","enter","trad-2.png"]
        actionList2=["tradS-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab7","enter","enter","trad-2.png"]  
    elif  菜单=="传统模式" and 开仓方向=="普通买入" and 平仓方向=="卖券还款":
        actionList1=["tradB-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab6","enter","enter","trad-2.png"]
        actionList2=["tradSH-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab7","enter","enter","trad-2.png"]  
    elif  菜单=="传统模式" and 开仓方向=="融资买入" and 平仓方向=="普通卖出":
        actionList1=["tradBR-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab6","enter","enter","trad-2.png"]
        actionList2=["tradS-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab7","enter","enter","trad-2.png"]   
    elif  菜单=="传统模式" and  开仓方向=="融资买入" and 平仓方向=="卖券还款":
        actionList1=["tradBR-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab6","enter","enter","trad-2.png"]
        actionList2=["tradSH-1.png","tab1","证券代码","tab1","超价","tab2","委托数量","tab2","enter","tab7","enter","enter","trad-2.png"]      

    # actionList1=[]
    # actionList2=[]
    # 随机开平次序
    if random.choice([0,1])==1:
        # 先开后平
        getAutoOutput(orderOpen,actionList1)
        log.info(f"开仓指令已执行,执行清单：{orderOpen},操作路径：{actionList1}")
        T0执行清单.loc[index,"开仓提交时间"]=f"{datetime.datetime.now().strftime('%H:%M:%S')}"
        T0执行清单.loc[index,"开仓提交时间-1分钟"]= f"{(datetime.datetime.now() - datetime.timedelta(seconds=20)).strftime('%H:%M:%S')}"
        T0执行清单.loc[index,"开仓提交时间+1分钟"]= f"{(datetime.datetime.now() + datetime.timedelta(seconds=20)).strftime('%H:%M:%S')}"
        time.sleep(20)
        getAutoOutput(orderClose,actionList2)
        log.info(f"平仓指令已执行,执行清单：{orderClose},操作路径：{actionList2}")
        T0执行清单.loc[index,"平仓提交时间"]=f"{datetime.datetime.now().strftime('%H:%M:%S')}"
        T0执行清单.loc[index,"平仓提交时间-1分钟"]= f"{(datetime.datetime.now() - datetime.timedelta(seconds=20)).strftime('%H:%M:%S')}"
        T0执行清单.loc[index,"平仓提交时间+1分钟"]=f"{(datetime.datetime.now() +datetime.timedelta(seconds=20)).strftime('%H:%M:%S')}"
        time.sleep(20)
    else:
        # 先平后开
        getAutoOutput(orderClose,actionList2)
        log.info(f"平仓指令已执行,执行清单：{orderClose},操作路径：{actionList2}")
        T0执行清单.loc[index,"平仓提交时间"]=f"{datetime.datetime.now().strftime('%H:%M:%S')}"
        T0执行清单.loc[index,"平仓提交时间-1分钟"]= f"{(datetime.datetime.now() - datetime.timedelta(seconds=20)).strftime('%H:%M:%S')}"
        T0执行清单.loc[index,"平仓提交时间+1分钟"]=f"{(datetime.datetime.now() +datetime.timedelta(seconds=20)).strftime('%H:%M:%S')}"
        time.sleep(20)
        getAutoOutput(orderOpen,actionList1)
        log.info(f"开仓指令已执行,执行清单：{orderOpen},操作路径：{actionList1}")
        T0执行清单.loc[index,"开仓提交时间"]=f"{datetime.datetime.now().strftime('%H:%M:%S')}"
        T0执行清单.loc[index,"开仓提交时间-1分钟"]= f"{(datetime.datetime.now() - datetime.timedelta(seconds=20)).strftime('%H:%M:%S')}"
        T0执行清单.loc[index,"开仓提交时间+1分钟"]=f"{(datetime.datetime.now() +datetime.timedelta(seconds=20)).strftime('%H:%M:%S')}"
        time.sleep(20)
    log.info(f"T0指令已执行,开仓:{开仓方向},平仓：{平仓方向},代码：{T0代码},数量：{T0数量}")

log.info(f"T0指令已全部执行")
saveCsvByTime("T0实际执行情况",T0执行清单,True)

#导出委托明细进行对比
actionList=["order-1.png","order-2.png","order-3.png","enter","tab1","enter"]
getAutoOutput([],actionList)
order_path=os.path.join(os.getcwd(),'当日委托.xlsx')
委托数据=pd.read_excel(order_path) 
# T0执行清单=pd.read_csv(r"C:\Users\AXZQ\Desktop\T0\T0实际执行情况_2023-05-28_11-28-54.csv")
# 委托数据=pd.read_excel(r"C:\Users\AXZQ\Desktop\T0\当日委托.xlsx") 
委托数据["证券代码"]=委托数据["证券代码"].apply(lambda x : '{:0>6d}'.format(x))   #补全6位

for index, row in T0执行清单.iterrows():
    T0代码=row["证券代码"][0:6]
    开仓方向=row["开仓方向"]
    if 开仓方向=="融券卖出":
        开仓方向="融券卖出(预约券)"
    elif 开仓方向=="普通买入":
        开仓方向="担保品买入"
    平仓方向=row["平仓方向"]
    if 开仓方向=="普通卖出":
        开仓方向="担保品卖出"
    T0数量=row["单轮委托量"]
    开仓提交时间早1分钟= datetime.datetime.strptime(row["开仓提交时间-1分钟"], "%H:%M:%S").time()
    开仓提交时间晚1分钟= datetime.datetime.strptime(row["开仓提交时间+1分钟"], "%H:%M:%S").time()
    平仓提交时间早1分钟=datetime.datetime.strptime(row["平仓提交时间-1分钟"], "%H:%M:%S").time()
    平仓提交时间晚1分钟=datetime.datetime.strptime(row["平仓提交时间+1分钟"], "%H:%M:%S").time()

   #增加开平仓是否委托成功 
    if len(委托数据[(开仓提交时间早1分钟<委托数据["委托时间"]) & (开仓提交时间晚1分钟>委托数据["委托时间"]) & (委托数据["证券代码"]==T0代码) & (委托数据["交易类型"]==开仓方向) & (委托数据["委托数量"]==T0数量)])==1:
        T0执行清单.loc[index,"开仓委托成功"]="Y"
        print("开仓已经委托成功")
    if len(委托数据[(开仓提交时间早1分钟<委托数据["委托时间"]) & (开仓提交时间晚1分钟>委托数据["委托时间"]) & (委托数据["证券代码"]==T0代码) & (委托数据["交易类型"]==开仓方向) & (委托数据["委托数量"]==T0数量)])==0:   
        T0执行清单.loc[index,"开仓委托成功"]="N"
        print("开仓已经委托失败")
    if len(委托数据[(平仓提交时间早1分钟<委托数据["委托时间"]) & (平仓提交时间晚1分钟>委托数据["委托时间"]) & (委托数据["证券代码"]==T0代码) & (委托数据["交易类型"]==平仓方向) & (委托数据["委托数量"]==T0数量)])==1:
        T0执行清单.loc[index,"平仓委托成功"]="Y"
        print("平仓已经委托成功")
    if len(委托数据[(平仓提交时间早1分钟<委托数据["委托时间"]) & (平仓提交时间晚1分钟>委托数据["委托时间"]) & (委托数据["证券代码"]==T0代码) & (委托数据["交易类型"]==平仓方向) & (委托数据["委托数量"]==T0数量)])==0:
        T0执行清单.loc[index,"平仓委托成功"]="N"
        print("平仓已经委托失败")
    print("-----------------------")
saveCsvByTime("T0委托实际执行情况",T0执行清单,True)
log.info("T0执行已追加委托执行情况")